kinde_sdk/management/management_client.py (1)

441-469: Always pass query params (incl. PATCH) and alias user_id→id; remove unused final_path.

• Ensures id is encoded via the client serializer.
• Keeps backward compatibility: positional first arg still works; user_id kwarg is mapped to id.
• Drops dead code (final_path) that’s never used.

Apply this diff:

@@
-            # Handle query params or body data based on HTTP method
-            query_params = None
-            body = None
-            
-            if http_method in ('GET', 'DELETE'):
-                query_params = {k: v for k, v in kwargs.items() if v is not None}
-            else:
-                body = {k: v for k, v in kwargs.items() if v is not None}
-            
-            # FIXED: Use param_serialize to properly construct the full URL with host
-            # Handle query parameters by appending them to the path
-            final_path = formatted_path
-            if query_params and http_method in ('GET', 'DELETE'):
-                query_string = '&'.join([f"{k}={v}" for k, v in query_params.items() if v is not None])
-                if query_string:
-                    separator = '&' if '?' in final_path else '?'
-                    final_path = f"{final_path}{separator}{query_string}"
+            # Handle query params or body data
+            query_params = None
+            body = None
+
+            if http_method in ('GET', 'DELETE'):
+                query_params = {k: v for k, v in kwargs.items() if v is not None}
+            else:
+                body = {k: v for k, v in kwargs.items() if v is not None}
+
+            # Users get/update/delete require an id in query string; accept id or user_id kwargs
+            # and also the first positional arg for back-compat.
+            if resource == 'users' and action in ('get', 'update', 'delete'):
+                positional_id = args[0] if args else None
+                canonical_id = kwargs.get('id', kwargs.get('user_id', positional_id))
+                if canonical_id is not None:
+                    query_params = (query_params or {})
+                    query_params['id'] = canonical_id
+                    # Ensure id fields don't leak into body or duplicate in query
+                    if body:
+                        body.pop('id', None)
+                        body.pop('user_id', None)
+                    query_params.pop('user_id', None)
@@
-            method, url, header_params, body, post_params = self.api_client.param_serialize(
+            _serialized_method, url, header_params, body, post_params = self.api_client.param_serialize(
                 method=http_method,
                 resource_path=resource_path_for_serialize,  # Use path without /api/v1 prefix
-                query_params=query_params if http_method in ('GET', 'DELETE') else None,
+                query_params=query_params or None,
                 header_params={},
                 body=body if http_method not in ('GET', 'DELETE') else None
             )

I can add focused unit tests for get_user/update_user/delete_user to assert the final serialized URL carries ?id=... and that kwargs don’t duplicate/bleed into the body. Want me to push those?

kinde_sdk/management/management_client.py (1)

436-457: Breaking change: positional args to get/update/delete user are now ignored. Map args → query_keys for back-compat and validate required keys.

Previously, get_user("abc") filled {user_id}. With /api/v1/user (no path placeholder), the current logic drops positional args and sends no id. Map positional args to declared query_keys (e.g., ['id']) and fail fast if required keys are missing. Also allow callers to pass _request_timeout without leaking it into query/body.

         def api_method(*args, **kwargs) -> Dict[str, Any]:
             # Format path with any path parameters from args
             formatted_path = path
             if '{' in path and args:
                 param_values = list(args)
                 while '{' in formatted_path and param_values:
                     start_idx = formatted_path.find('{')
                     end_idx = formatted_path.find('}')
                     if start_idx >= 0 and end_idx >= 0:
                         formatted_path = formatted_path[:start_idx] + str(param_values.pop(0)) + formatted_path[end_idx + 1:]
 
+            # Allow method-level timeout without polluting query/body
+            _request_timeout = kwargs.pop('_request_timeout', None)
+
+            # Back-compat: if no placeholders but we have declared query_keys, map positional args -> query keys
+            if '{' not in path and args and query_keys:
+                for i, key in enumerate(query_keys):
+                    if i < len(args) and key not in kwargs:
+                        kwargs[key] = args[i]
+
+            # Validate required query keys when declared
+            if query_keys:
+                missing = [k for k in query_keys if kwargs.get(k) is None]
+                if missing:
+                    raise ValueError(f"Missing required query parameter(s): {', '.join(missing)}")
             # Handle query/body split
             if http_method in ('GET', 'DELETE'):
                 query_params = {k: v for k, v in kwargs.items() if v is not None}
                 payload = None
             else:
                 # Lift ONLY declared query_keys into the query string
                 qset = set(query_keys or ())
                 query_params = {k: kwargs.pop(k) for k in list(kwargs) if k in qset and kwargs[k] is not None}
                 # Remaining kwargs go to JSON body
                 payload = {k: v for k, v in kwargs.items() if v is not None}

And pass the timeout to the request (see comment below).